package com.webank.tikv.kvproto;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.68.1)",
    comments = "Source: pdpb.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class PDGrpc {

  private PDGrpc() {}

  public static final java.lang.String SERVICE_NAME = "pdpb.PD";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetMembersRequest,
      com.webank.tikv.kvproto.Pdpb.GetMembersResponse> getGetMembersMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetMembers",
      requestType = com.webank.tikv.kvproto.Pdpb.GetMembersRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetMembersResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetMembersRequest,
      com.webank.tikv.kvproto.Pdpb.GetMembersResponse> getGetMembersMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetMembersRequest, com.webank.tikv.kvproto.Pdpb.GetMembersResponse> getGetMembersMethod;
    if ((getGetMembersMethod = PDGrpc.getGetMembersMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetMembersMethod = PDGrpc.getGetMembersMethod) == null) {
          PDGrpc.getGetMembersMethod = getGetMembersMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetMembersRequest, com.webank.tikv.kvproto.Pdpb.GetMembersResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetMembers"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetMembersRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetMembersResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetMembers"))
              .build();
        }
      }
    }
    return getGetMembersMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.TsoRequest,
      com.webank.tikv.kvproto.Pdpb.TsoResponse> getTsoMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Tso",
      requestType = com.webank.tikv.kvproto.Pdpb.TsoRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.TsoResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.TsoRequest,
      com.webank.tikv.kvproto.Pdpb.TsoResponse> getTsoMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.TsoRequest, com.webank.tikv.kvproto.Pdpb.TsoResponse> getTsoMethod;
    if ((getTsoMethod = PDGrpc.getTsoMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getTsoMethod = PDGrpc.getTsoMethod) == null) {
          PDGrpc.getTsoMethod = getTsoMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.TsoRequest, com.webank.tikv.kvproto.Pdpb.TsoResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Tso"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.TsoRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.TsoResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("Tso"))
              .build();
        }
      }
    }
    return getTsoMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetStoreRequest,
      com.webank.tikv.kvproto.Pdpb.GetStoreResponse> getGetStoreMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetStore",
      requestType = com.webank.tikv.kvproto.Pdpb.GetStoreRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetStoreResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetStoreRequest,
      com.webank.tikv.kvproto.Pdpb.GetStoreResponse> getGetStoreMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetStoreRequest, com.webank.tikv.kvproto.Pdpb.GetStoreResponse> getGetStoreMethod;
    if ((getGetStoreMethod = PDGrpc.getGetStoreMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetStoreMethod = PDGrpc.getGetStoreMethod) == null) {
          PDGrpc.getGetStoreMethod = getGetStoreMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetStoreRequest, com.webank.tikv.kvproto.Pdpb.GetStoreResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStore"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetStoreRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetStoreResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetStore"))
              .build();
        }
      }
    }
    return getGetStoreMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest,
      com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse> getGetAllStoresMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAllStores",
      requestType = com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest,
      com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse> getGetAllStoresMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest, com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse> getGetAllStoresMethod;
    if ((getGetAllStoresMethod = PDGrpc.getGetAllStoresMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetAllStoresMethod = PDGrpc.getGetAllStoresMethod) == null) {
          PDGrpc.getGetAllStoresMethod = getGetAllStoresMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest, com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllStores"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetAllStores"))
              .build();
        }
      }
    }
    return getGetAllStoresMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionRequest,
      com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetRegionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetRegion",
      requestType = com.webank.tikv.kvproto.Pdpb.GetRegionRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetRegionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionRequest,
      com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetRegionMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionRequest, com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetRegionMethod;
    if ((getGetRegionMethod = PDGrpc.getGetRegionMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetRegionMethod = PDGrpc.getGetRegionMethod) == null) {
          PDGrpc.getGetRegionMethod = getGetRegionMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetRegionRequest, com.webank.tikv.kvproto.Pdpb.GetRegionResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetRegion"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetRegionRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetRegionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetRegion"))
              .build();
        }
      }
    }
    return getGetRegionMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionRequest,
      com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetPrevRegionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetPrevRegion",
      requestType = com.webank.tikv.kvproto.Pdpb.GetRegionRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetRegionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionRequest,
      com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetPrevRegionMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionRequest, com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetPrevRegionMethod;
    if ((getGetPrevRegionMethod = PDGrpc.getGetPrevRegionMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetPrevRegionMethod = PDGrpc.getGetPrevRegionMethod) == null) {
          PDGrpc.getGetPrevRegionMethod = getGetPrevRegionMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetRegionRequest, com.webank.tikv.kvproto.Pdpb.GetRegionResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetPrevRegion"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetRegionRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetRegionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetPrevRegion"))
              .build();
        }
      }
    }
    return getGetPrevRegionMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest,
      com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetRegionByIDMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetRegionByID",
      requestType = com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetRegionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest,
      com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetRegionByIDMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest, com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getGetRegionByIDMethod;
    if ((getGetRegionByIDMethod = PDGrpc.getGetRegionByIDMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetRegionByIDMethod = PDGrpc.getGetRegionByIDMethod) == null) {
          PDGrpc.getGetRegionByIDMethod = getGetRegionByIDMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest, com.webank.tikv.kvproto.Pdpb.GetRegionResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetRegionByID"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetRegionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetRegionByID"))
              .build();
        }
      }
    }
    return getGetRegionByIDMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest,
      com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse> getScanRegionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ScanRegions",
      requestType = com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest,
      com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse> getScanRegionsMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest, com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse> getScanRegionsMethod;
    if ((getScanRegionsMethod = PDGrpc.getScanRegionsMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getScanRegionsMethod = PDGrpc.getScanRegionsMethod) == null) {
          PDGrpc.getScanRegionsMethod = getScanRegionsMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest, com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ScanRegions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("ScanRegions"))
              .build();
        }
      }
    }
    return getScanRegionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest,
      com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse> getGetClusterConfigMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetClusterConfig",
      requestType = com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest,
      com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse> getGetClusterConfigMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest, com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse> getGetClusterConfigMethod;
    if ((getGetClusterConfigMethod = PDGrpc.getGetClusterConfigMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetClusterConfigMethod = PDGrpc.getGetClusterConfigMethod) == null) {
          PDGrpc.getGetClusterConfigMethod = getGetClusterConfigMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest, com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClusterConfig"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetClusterConfig"))
              .build();
        }
      }
    }
    return getGetClusterConfigMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest,
      com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse> getGetDCLocationInfoMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetDCLocationInfo",
      requestType = com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest,
      com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse> getGetDCLocationInfoMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest, com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse> getGetDCLocationInfoMethod;
    if ((getGetDCLocationInfoMethod = PDGrpc.getGetDCLocationInfoMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getGetDCLocationInfoMethod = PDGrpc.getGetDCLocationInfoMethod) == null) {
          PDGrpc.getGetDCLocationInfoMethod = getGetDCLocationInfoMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest, com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetDCLocationInfo"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("GetDCLocationInfo"))
              .build();
        }
      }
    }
    return getGetDCLocationInfoMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest,
      com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse> getSplitRegionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SplitRegions",
      requestType = com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest.class,
      responseType = com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest,
      com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse> getSplitRegionsMethod() {
    io.grpc.MethodDescriptor<com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest, com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse> getSplitRegionsMethod;
    if ((getSplitRegionsMethod = PDGrpc.getSplitRegionsMethod) == null) {
      synchronized (PDGrpc.class) {
        if ((getSplitRegionsMethod = PDGrpc.getSplitRegionsMethod) == null) {
          PDGrpc.getSplitRegionsMethod = getSplitRegionsMethod =
              io.grpc.MethodDescriptor.<com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest, com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SplitRegions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new PDMethodDescriptorSupplier("SplitRegions"))
              .build();
        }
      }
    }
    return getSplitRegionsMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static PDStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<PDStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<PDStub>() {
        @java.lang.Override
        public PDStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new PDStub(channel, callOptions);
        }
      };
    return PDStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static PDBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<PDBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<PDBlockingStub>() {
        @java.lang.Override
        public PDBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new PDBlockingStub(channel, callOptions);
        }
      };
    return PDBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static PDFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<PDFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<PDFutureStub>() {
        @java.lang.Override
        public PDFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new PDFutureStub(channel, callOptions);
        }
      };
    return PDFutureStub.newStub(factory, channel);
  }

  /**
   */
  public interface AsyncService {

    /**
     * <pre>
     * GetMembers get the member list of this cluster. It does not require
     * the cluster_id in request matchs the id of this cluster.
     * </pre>
     */
    default void getMembers(com.webank.tikv.kvproto.Pdpb.GetMembersRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetMembersResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetMembersMethod(), responseObserver);
    }

    /**
     */
    default io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.TsoRequest> tso(
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.TsoResponse> responseObserver) {
      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getTsoMethod(), responseObserver);
    }

    /**
     */
    default void getStore(com.webank.tikv.kvproto.Pdpb.GetStoreRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetStoreResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStoreMethod(), responseObserver);
    }

    /**
     */
    default void getAllStores(com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAllStoresMethod(), responseObserver);
    }

    /**
     */
    default void getRegion(com.webank.tikv.kvproto.Pdpb.GetRegionRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetRegionMethod(), responseObserver);
    }

    /**
     */
    default void getPrevRegion(com.webank.tikv.kvproto.Pdpb.GetRegionRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetPrevRegionMethod(), responseObserver);
    }

    /**
     */
    default void getRegionByID(com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetRegionByIDMethod(), responseObserver);
    }

    /**
     */
    default void scanRegions(com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getScanRegionsMethod(), responseObserver);
    }

    /**
     */
    default void getClusterConfig(com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClusterConfigMethod(), responseObserver);
    }

    /**
     */
    default void getDCLocationInfo(com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDCLocationInfoMethod(), responseObserver);
    }

    /**
     */
    default void splitRegions(com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSplitRegionsMethod(), responseObserver);
    }
  }

  /**
   * Base class for the server implementation of the service PD.
   */
  public static abstract class PDImplBase
      implements io.grpc.BindableService, AsyncService {

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return PDGrpc.bindService(this);
    }
  }

  /**
   * A stub to allow clients to do asynchronous rpc calls to service PD.
   */
  public static final class PDStub
      extends io.grpc.stub.AbstractAsyncStub<PDStub> {
    private PDStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected PDStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new PDStub(channel, callOptions);
    }

    /**
     * <pre>
     * GetMembers get the member list of this cluster. It does not require
     * the cluster_id in request matchs the id of this cluster.
     * </pre>
     */
    public void getMembers(com.webank.tikv.kvproto.Pdpb.GetMembersRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetMembersResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetMembersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.TsoRequest> tso(
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.TsoResponse> responseObserver) {
      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
          getChannel().newCall(getTsoMethod(), getCallOptions()), responseObserver);
    }

    /**
     */
    public void getStore(com.webank.tikv.kvproto.Pdpb.GetStoreRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetStoreResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetStoreMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getAllStores(com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetAllStoresMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getRegion(com.webank.tikv.kvproto.Pdpb.GetRegionRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetRegionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getPrevRegion(com.webank.tikv.kvproto.Pdpb.GetRegionRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetPrevRegionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getRegionByID(com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetRegionByIDMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void scanRegions(com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getScanRegionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getClusterConfig(com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetClusterConfigMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getDCLocationInfo(com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDCLocationInfoMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void splitRegions(com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest request,
        io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSplitRegionsMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * A stub to allow clients to do synchronous rpc calls to service PD.
   */
  public static final class PDBlockingStub
      extends io.grpc.stub.AbstractBlockingStub<PDBlockingStub> {
    private PDBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected PDBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new PDBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     * GetMembers get the member list of this cluster. It does not require
     * the cluster_id in request matchs the id of this cluster.
     * </pre>
     */
    public com.webank.tikv.kvproto.Pdpb.GetMembersResponse getMembers(com.webank.tikv.kvproto.Pdpb.GetMembersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetMembersMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetStoreResponse getStore(com.webank.tikv.kvproto.Pdpb.GetStoreRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetStoreMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse getAllStores(com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAllStoresMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetRegionResponse getRegion(com.webank.tikv.kvproto.Pdpb.GetRegionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetRegionMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetRegionResponse getPrevRegion(com.webank.tikv.kvproto.Pdpb.GetRegionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetPrevRegionMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetRegionResponse getRegionByID(com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetRegionByIDMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse scanRegions(com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getScanRegionsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse getClusterConfig(com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetClusterConfigMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse getDCLocationInfo(com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDCLocationInfoMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse splitRegions(com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSplitRegionsMethod(), getCallOptions(), request);
    }
  }

  /**
   * A stub to allow clients to do ListenableFuture-style rpc calls to service PD.
   */
  public static final class PDFutureStub
      extends io.grpc.stub.AbstractFutureStub<PDFutureStub> {
    private PDFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected PDFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new PDFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     * GetMembers get the member list of this cluster. It does not require
     * the cluster_id in request matchs the id of this cluster.
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetMembersResponse> getMembers(
        com.webank.tikv.kvproto.Pdpb.GetMembersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetMembersMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetStoreResponse> getStore(
        com.webank.tikv.kvproto.Pdpb.GetStoreRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetStoreMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse> getAllStores(
        com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetAllStoresMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getRegion(
        com.webank.tikv.kvproto.Pdpb.GetRegionRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetRegionMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getPrevRegion(
        com.webank.tikv.kvproto.Pdpb.GetRegionRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetPrevRegionMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetRegionResponse> getRegionByID(
        com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetRegionByIDMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse> scanRegions(
        com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getScanRegionsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse> getClusterConfig(
        com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetClusterConfigMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse> getDCLocationInfo(
        com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDCLocationInfoMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse> splitRegions(
        com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSplitRegionsMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_GET_MEMBERS = 0;
  private static final int METHODID_GET_STORE = 1;
  private static final int METHODID_GET_ALL_STORES = 2;
  private static final int METHODID_GET_REGION = 3;
  private static final int METHODID_GET_PREV_REGION = 4;
  private static final int METHODID_GET_REGION_BY_ID = 5;
  private static final int METHODID_SCAN_REGIONS = 6;
  private static final int METHODID_GET_CLUSTER_CONFIG = 7;
  private static final int METHODID_GET_DCLOCATION_INFO = 8;
  private static final int METHODID_SPLIT_REGIONS = 9;
  private static final int METHODID_TSO = 10;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final AsyncService serviceImpl;
    private final int methodId;

    MethodHandlers(AsyncService serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_GET_MEMBERS:
          serviceImpl.getMembers((com.webank.tikv.kvproto.Pdpb.GetMembersRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetMembersResponse>) responseObserver);
          break;
        case METHODID_GET_STORE:
          serviceImpl.getStore((com.webank.tikv.kvproto.Pdpb.GetStoreRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetStoreResponse>) responseObserver);
          break;
        case METHODID_GET_ALL_STORES:
          serviceImpl.getAllStores((com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse>) responseObserver);
          break;
        case METHODID_GET_REGION:
          serviceImpl.getRegion((com.webank.tikv.kvproto.Pdpb.GetRegionRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse>) responseObserver);
          break;
        case METHODID_GET_PREV_REGION:
          serviceImpl.getPrevRegion((com.webank.tikv.kvproto.Pdpb.GetRegionRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse>) responseObserver);
          break;
        case METHODID_GET_REGION_BY_ID:
          serviceImpl.getRegionByID((com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetRegionResponse>) responseObserver);
          break;
        case METHODID_SCAN_REGIONS:
          serviceImpl.scanRegions((com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse>) responseObserver);
          break;
        case METHODID_GET_CLUSTER_CONFIG:
          serviceImpl.getClusterConfig((com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse>) responseObserver);
          break;
        case METHODID_GET_DCLOCATION_INFO:
          serviceImpl.getDCLocationInfo((com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse>) responseObserver);
          break;
        case METHODID_SPLIT_REGIONS:
          serviceImpl.splitRegions((com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest) request,
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_TSO:
          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.tso(
              (io.grpc.stub.StreamObserver<com.webank.tikv.kvproto.Pdpb.TsoResponse>) responseObserver);
        default:
          throw new AssertionError();
      }
    }
  }

  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
        .addMethod(
          getGetMembersMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetMembersRequest,
              com.webank.tikv.kvproto.Pdpb.GetMembersResponse>(
                service, METHODID_GET_MEMBERS)))
        .addMethod(
          getTsoMethod(),
          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.TsoRequest,
              com.webank.tikv.kvproto.Pdpb.TsoResponse>(
                service, METHODID_TSO)))
        .addMethod(
          getGetStoreMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetStoreRequest,
              com.webank.tikv.kvproto.Pdpb.GetStoreResponse>(
                service, METHODID_GET_STORE)))
        .addMethod(
          getGetAllStoresMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetAllStoresRequest,
              com.webank.tikv.kvproto.Pdpb.GetAllStoresResponse>(
                service, METHODID_GET_ALL_STORES)))
        .addMethod(
          getGetRegionMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetRegionRequest,
              com.webank.tikv.kvproto.Pdpb.GetRegionResponse>(
                service, METHODID_GET_REGION)))
        .addMethod(
          getGetPrevRegionMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetRegionRequest,
              com.webank.tikv.kvproto.Pdpb.GetRegionResponse>(
                service, METHODID_GET_PREV_REGION)))
        .addMethod(
          getGetRegionByIDMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetRegionByIDRequest,
              com.webank.tikv.kvproto.Pdpb.GetRegionResponse>(
                service, METHODID_GET_REGION_BY_ID)))
        .addMethod(
          getScanRegionsMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.ScanRegionsRequest,
              com.webank.tikv.kvproto.Pdpb.ScanRegionsResponse>(
                service, METHODID_SCAN_REGIONS)))
        .addMethod(
          getGetClusterConfigMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetClusterConfigRequest,
              com.webank.tikv.kvproto.Pdpb.GetClusterConfigResponse>(
                service, METHODID_GET_CLUSTER_CONFIG)))
        .addMethod(
          getGetDCLocationInfoMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoRequest,
              com.webank.tikv.kvproto.Pdpb.GetDCLocationInfoResponse>(
                service, METHODID_GET_DCLOCATION_INFO)))
        .addMethod(
          getSplitRegionsMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.webank.tikv.kvproto.Pdpb.SplitRegionsRequest,
              com.webank.tikv.kvproto.Pdpb.SplitRegionsResponse>(
                service, METHODID_SPLIT_REGIONS)))
        .build();
  }

  private static abstract class PDBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    PDBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.webank.tikv.kvproto.Pdpb.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("PD");
    }
  }

  private static final class PDFileDescriptorSupplier
      extends PDBaseDescriptorSupplier {
    PDFileDescriptorSupplier() {}
  }

  private static final class PDMethodDescriptorSupplier
      extends PDBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final java.lang.String methodName;

    PDMethodDescriptorSupplier(java.lang.String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (PDGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new PDFileDescriptorSupplier())
              .addMethod(getGetMembersMethod())
              .addMethod(getTsoMethod())
              .addMethod(getGetStoreMethod())
              .addMethod(getGetAllStoresMethod())
              .addMethod(getGetRegionMethod())
              .addMethod(getGetPrevRegionMethod())
              .addMethod(getGetRegionByIDMethod())
              .addMethod(getScanRegionsMethod())
              .addMethod(getGetClusterConfigMethod())
              .addMethod(getGetDCLocationInfoMethod())
              .addMethod(getSplitRegionsMethod())
              .build();
        }
      }
    }
    return result;
  }
}
